#include <iostream>
using std::cout;
using std::endl;

class Point{
public:
    Point(int x, int y)
    :_x(x)
    ,_y(y)
    {
        cout << "Point(int,int)" << endl;
    }

    Point(const Point & rhs)
    :_x(rhs._x)
    ,_y(rhs._y)
    {
        cout << "Point(const Point &)" << endl;
    }

    //赋值运算符函数 pt = pt2;
    //rhs就是有操作数pt2
    //将rhs的数据成员的值赋值给当前的数据成员
    Point & operator=(const Point & rhs){
        _x = rhs._x;
        _y = rhs._y;
        //当前成员函数对应的对象返回
        return *this;
    }

    //这个函数是我们编写代码时，我们写的函数形式
    void print(){
        cout << _x << "," << _y << endl;
    }
#if 0
    //但是该函数被编译器处理过后，会变成
    void print(Point * const this){
        cout << this->_x << "," << this->_y << endl;
    }
    pt.print()-------->print(&pt);
    pt2.print()-------->print(&pt2);
#endif


private:
    int _x;
    int _y;


};
void test(){
    Point pt1(1, 2), pt2(3, 4);
    pt1.print();
    pt2.print();
    pt1 = pt2;//赋值操作
    //背后编译器实际上调用的便是
    //pt1.operator=(pt2);
    cout << "========" << endl;
    pt1.print();
    pt2.print();

}

void test2(){
    //根据之前所说的类的大小、类的内存布局
    //为什么每次对象调用自己的成员函数都没有出错
    //成员函数并没有在对象所属的这块内存空间中
    //成员函数没有必要存储多份，其实只需要存储一份即可
    //为什么多个对象，去调用始终显示的是该对象的数据成员呢？没有出错
    //原因就在于成员函数实际上被编译器解析过后会有一个隐形的参数
    //其实就是this指针，指的是当前调用该函数的对象地址
    //this指针类型：Type * const this
    Point pt(2,4);
    pt.print();

    Point pt2(1,5);
    pt2.print();
}

int main()
{
    test2();
    return 0;
}

